<?xml version="1.0" encoding="UTF-8"?>
<html>
    <head>
        <link type="text/css" rel="stylesheet" href="./css/template.css" />
        <link type="text/css" rel="stylesheet" href="./css/SyntaxHighlighter.css" />
        <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
        <title>Eclipse RCP</title>
        <script language="javascript" src="./js/shInit.js" />
        <script language="javascript" src="./js/shCore.js" />
        <script language="javascript" src="./js/shBrushCpp.js" />
        <script language="javascript" src="./js/shBrushCSharp.js" />
        <script language="javascript" src="./js/shBrushCss.js" />
        <script language="javascript" src="./js/shBrushDelphi.js" />
        <script language="javascript" src="./js/shBrushJava.js" />
        <script language="javascript" src="./js/shBrushJScript.js" />
        <script language="javascript" src="./js/shBrushPhp.js" />
        <script language="javascript" src="./js/shBrushPython.js" />
        <script language="javascript" src="./js/shBrushRuby.js" />
        <script language="javascript" src="./js/shBrushSql.js" />
        <script language="javascript" src="./js/shBrushVb.js" />
        <script language="javascript" src="./js/shBrushXml.js" />
        <keywords>eclipse,Eclipse,Eclipse,eclipse,rcp,articles,2,4,certification,sun,java,solaris,articles,essentiels,tips,astuces,codes,exemple,tutorial,developpement,jsp,servlet,jdbc,jdo,j2se,j2ee,laboratoire</keywords>
        <author>Alexandre PICON</author>
    </head>
    <body>
        <div class="chapter">
            <h2>Introduction</h2>
            <p>On ne présente plus le célèbre environnement de développement d’applications Eclipse. Sa structure modulable, basé sur des plug-in, l’a rendu très populaire au sein de la communauté des développeurs Java. Ce que l’on sait moins c’est qu’il est tout à fait possible de se baser sur des composants d’Eclipse pour réaliser des interfaces graphiques pour d’autres applications.</p>
            <p>En effet, la version 3.0 d’Eclipse a introduit le principe de « Rich Client Platform ». Comme son nom l’indique, Eclipse RCP permet de créer des applications « Client riche » (applications entièrement déployées sur le poste client).</p>
            <p>Eclipse RCP est, en quelque sorte, une version simplifiée de l’IDE Eclipse dont on a enlevé les modules couvrant les besoins spécifiques à un environnement de développement.
				Il est donc possible de réutiliser cette base pour développer des applications clientes dîtes riches.</p>
            <p>Il est tout d’abord utile de rappeler la structure de la base d’Eclipse sur laquelle il faut se baser pour réaliser des applications avec Eclipse RCP :</p>
            <ul>
                <li>Plateform runtime</li>
                <li>SWT</li>
                <li>JFace</li>
                <li>Workbench</li>
                <li>Platform runtime : Démarre la plateforme et gère les plug-in.</li>
            </ul>
            <p>SWT : C’est la librairie graphique de base de l’EDI. SWT a été créé afin de doter Eclipse d’une librairie graphique performante qui permet de produire des interfaces graphiques très réactives et parfaitement intégrées au système d'exploitation</p>
            <p>JFace : C’est une une librairie graphique de plus haut niveau basée sur SWT. JFace est composé d’un ensemble d’outils qui permettent de simplifier l’utilisation de SWT en proposant un certain nombre de fonctionnalités (notion de commandes pour les raccourcis clavier, boîtes de dialogues personnalisées, support du modèle MVC avec la notion de vues…).</p>
            <p>Workbench : C’est la dernière couche graphique permettant de manipuler des composants d’Eclipse tels que des vues, des éditeurs, des perspectives...</p>
            <p>C’est en réutilisant ces composants de base d’Eclipse qu’il est possible de développer des applications « client riche » grâce à Eclipse RCP.</p>
            <p>Nous allons voir comment tout cela est possible à travers un premier exemple simple puis nous irons plus loin en se basant sur un exemple un peu plus compliqué.</p>
        </div>
        <div class="chapter">
            <h2>2.Premier exemple</h2>
            <p>Pour créer une application RCP, il faut faire un nouveau projet de plug in :</p>
            <p>
                <strong>File -&gt; New -&gt; Project</strong>
                , dans
                <strong>Plug-in developpement</strong>
                sélectionner
                <strong>Plug-in project</strong>
                .Il faut ensuite entrer le nom du projet, laisser les options par défaut puis cliquer sur
                <strong>Next</strong>
                .Sur l’écran suivant, pour l’option "Would you like to create a rich client application ", sélectionner
                <strong>Oui</strong>
                .
            </p>
            <p>
                On obtient alors différents templates sur lequels on peut se baser et créer notre propre application. Pour cet exemple, nous allons utiliser le premier template (« Hello RCP »). Il faut donc sélectionner
                <strong>Hello Template</strong>
                puis cliquer sur
                <strong>Finish</strong>
                .
            </p>
            <p>Vous devriez avoir l’écran suivant :</p>
            <img src="./images/article-EclipseRCP_html_dfae8bd.png" />
            <p>Il s’agit du PDE (Plugin Development Environment) qui permet d’automatiser certaines tâches pour la création de plugin.</p>
            <p>Vous pouvez lancer l’exemple en cliquant sur « Launch an Eclipse application » ce qui donne ceci :</p>
            <img src="./images/article-EclipseRCP_html_m40c09d75.png" />
            <p>Nous allons maintenant détailler le code qui a été généré par l’assistant.</p>
            <div class="subChapter">
                <h3>2.1 La classe Application (Application.java)</h3>
                <p>Cette classe ne sert qu’à contrôler les aspects de l’exécution de l’application.</p>
                <textarea name="code" class="java">public class Application implements IPlatformRunnable {
					public Object run(Object args) throws Exception {
					Display display = PlatformUI.createDisplay();
					try {
					int returnCode = PlatformUI.createAndRunWorkbench(display, new ApplicationWorkbenchAdvisor());
					if (returnCode == PlatformUI.RETURN_RESTART) {
					return IPlatformRunnable.EXIT_RESTART;
					}catch{
					return IPlatformRunnable.EXIT_OK;
					}finally {
					display.dispose();
					}
					}
					}</textarea>
                <p>
                    <strong>La classe Application.java:</strong>
                </p>
                <p>Cette classe implémente l’interface IPlatformRunnable. Dans la méthode run(), on crée un workbench avec en paramètre un Workbench Advisor (nous verrons ce que c’est dans la suite de cet article).</p>
            </div>
            <div class="subChapter">
                <h3>2.2. La classe Perspective (Perspective.java)</h3>
                <p>Une perspective représente un ensemble de vues, éditeurs et menus de l’application. Il est obligatoire, avec RCP, de définir au moins une perspective (ce sera alors la perspective par défaut).</p>
                <p>Une perspective implémente l’interface IPerspectiveFactory et la méthode createInitialLayout() qui permet de définir la position et chaque vues ou editeurs.</p>
            </div>
            <div class="subChapter">
                <h3>2.3. Les Advisor Class</h3>
                <p>Il en existe plusieurs type (« Workbench Advisor », « Workbench Window Advisor », “ApplicationActionBarAdvisor”).</p>
                Ils permettent de contrôler tous les éléments du Workbench
                <h4>2.3.1. Workench Advisor</h4>
                <p>Son rôle principal est de définir la perspective par défaut de l’application.</p>
                <textarea name="code" class="java">public class ApplicationWorkbenchAdvisor extends WorkbenchAdvisor {
					private static final String PERSPECTIVE_ID = "com.supinfo.eclipseRCP.exemple.perspective";
					public WorkbenchWindowAdvisor createWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
					return new ApplicationWorkbenchWindowAdvisor(configurer);
					}
					public String getInitialWindowPerspectiveId() {
					return PERSPECTIVE_ID;
					}</textarea>
                <p>
                    <strong>ApplicationWorckbenchAdvisor.java</strong>
                </p>
                <p>Il faut obligatoirement déclarer une chaîne représentant l’id de la perspective principale (celui déclaré dans le fichier de configuration plugin.xml) et redéfinir la méthode getInitialWindowPerspectiveId ».</p>
                <p>Il est également possible de redéfinir d’autres méthodes qui sont optionnelles :</p>
                <ul>
                    <li>getDefaultPageInput : définit le point d’entrée par défaut pour les nouvelles pages workbench.</li>
                    <li>getMainPreferencePageId : définit la perspective qui sera affichée en premier.</li>
                </ul>
                <h4>2.3.2. Workench Window Advisor</h4>
                <p>Cette classe permet de contrôler le comportement de la fenêtre (taille, titre) et les composants qui sont présents par défaut (barre de statut, barre d’outils).</p>
                <textarea name="code" class="java">public class ApplicationWorkbenchWindowAdvisor extends WorkbenchWindowAdvisor {
					public ApplicationWorkbenchWindowAdvisor(IWorkbenchWindowConfigurer configurer) {
					super(configurer);
					}
					public ActionBarAdvisor createActionBarAdvisor(IActionBarConfigurer configurer) {
					return new ApplicationActionBarAdvisor(configurer);
					}
					public void preWindowOpen() {
					IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
					configurer.setInitialSize(new Point(400, 300));
					configurer.setShowCoolBar(false);
					configurer.setShowStatusLine(false);
					configurer.setTitle("Hello RCP");
					}
					}</textarea>
                <p>
                    <strong>ApplictionWorkbenchWindowAdisor.java</strong>
                </p>
                <p>Ici, on crée un « configurer interface » puis on définit la taille et le titre de l’application dans la méthode preWindowOpen.</p>
                <h4>2.3.3. Action Bar Advisor</h4>
                <p>Cette classe gère les différentes actions pour les « ActionBar » c'est-à-dire les barres de menu, cool bar et barre de statut. Les différentes méthodes que l’on peut utiliser sont :</p>
                <ul>
                    <li>makeActions permet de definir des actions pour chaque menu.</li>
                    <li>fillMenuBar permet de remplir la barre de menu</li>
                    <li>fillCoolBar permet de remplir la cool bar</li>
                    <li>fillStatusLine permet de remplir la barre de statut.</li>
                </ul>
            </div>
            <div class="subChapter">
                <h3>2.4  Le fichier plugin.xml</h3>
                <p>Il permet de définir la structure de notre application Eclipse RCP. Il faut y faire figurer, par exemple, l’emplacement de la classe Application, la perspective par défaut, les vues…</p>
            </div>
            <div class="subChapter">
                <h3>2.5 Résumé</h3>
                <p>Pour résumer, une application Eclipse RCP se compose d’un fichier de description plugin.xml, d’une classe Application qui gère l’exécution de l’application et qui crée un nouveau « Workbench Advisor ». Ce Workbench Advisor défini la perspective par défaut de l’application. Sur cette perspective il sera possible de définir les différentes vues de notre application. Ensuite, la classe WorkbenchWindowAdvisor permet de définir le comportement de notre fenêtre (taille, titre…) et la présence ou non sur notre fenêtre des « ActionBar » (barre de menu, de statut…). Les « Action Bar » sont ensuite gérées dans la classe ActionBarAdvisor.</p>
            </div>
        </div>
        <div class="chapter">
            <h2>3. Deuxième exemple</h2>
            <p>Nous allons partir de notre première application puisque toutes les classes de bases y sont déjà présentes (Application, Workbench Advisor…) et la modifier pour réaliser une application un peu plus compliquée avec plusieurs vues, un menu et différentes actions sur ces menus.</p>
            <p>Nous allons donc d’abord modifier la classe ApplicationWorckbenchAdvisor.java afin de changer le titre et la taille de la fenêtre et spécifier que la barre de menu doit être visible :</p>
            <textarea name="code" class="java">public void preWindowOpen() {
				IWorkbenchWindowConfigurer configurer = getWindowConfigurer();
				configurer.setInitialSize(new Point(1000, 800));
				configurer.setShowMenuBar(true);
				configurer.setShowCoolBar(false);
				configurer.setShowStatusLine(false);
				configurer.setTitle("Application Eclipse RCP");
				}</textarea>
            <p>Il faut ensuite ajouter plusieurs vues sur notre application. Il faut donc modifier la classe Perspective.java qui contient l’ensemble des vues :</p>
            <textarea name="code" class="java">public void createInitialLayout(IPageLayout layout){
				/* On cache l'éditeur qui est placé par défaut par eclipse RCP */
				String editorArea = layout.getEditorArea();
				layout.setEditorAreaVisible(false);
				// On ajoute deux nouvelles vues
				IFolderLayout folder = layout.createFolder("Onglets", IPageLayout.TOP, 0.5f, editorArea);
				folder.addPlaceholder(MyView.ID + ":*");
				folder.addView(MyView.ID);
				//une vue à droite
				layout.addStandaloneView(MyViewRight.ID, false,IPageLayout.RIGHT, 1.0f, IPageLayout.ID_EDITOR_AREA);
				layout.getViewLayout(MyViewRight.ID).setCloseable(true);
				}</textarea>
            <p>On a ici caché la vue qu’affiche Eclipse RCP par défaut puis nous avons défini une vue à partir de l’interface IFolderLayout (qui permet d’afficher un éditeur avec un système d’onglets comme dans Eclipse) qui sera affiché en haut à gauche (IPageLayout.TOP). La deuxième vue est une vue simple, qui sera située sur la droite de l’application.</p>
            <p>La dernière ligne permet d’empêcher la fermeture de la vue de droite. A noter qu’à chaque fois, les méthodes addView et addStandaloneView (c’est une vue qui ne peut être arimée) prennent comme paramètre l’ID de la vue qui sera affiché. Lors de l’exécution, le runtime va alors aller chercher dans le fichier plug-in.xml l’id de la vue et va instancier la classe correspondante.</p>
            <p>Il faut donc aller ajouter dans plug-in.xml un nouvel élément View (vue) avec comme paramètre la classe correspondante à cette vue. Pour cela, il faut retourner sur l’interface de développement de plug-in (PDE) dans l’onglet « extensions ».</p>
            <img src="./images/article-EclipseRCP_html_36f3ed2.png" />
            <p>Pour ajouter une nouvelle vue, il faut cliquer sur Add, sélectionner org.eclipse.ui.views puis cliquer sur Finish. Il faut ensuite donner un identifiant à notre vue (par exemple « myview ») et un nom (« myview » également). Il faut aussi préciser à quelle classe cette vue correspond. Il faut donc aller dans l’onglet plugin.xml et ajouter le nom de la classe à l’endroit où l’assistant a décrit notre vue :</p>
            <textarea name="code" class="xml">
                <extension id="com.supinfo.eclipseRCP.exemple.MyView" point="org.eclipse.ui.views">
                    <view id="myview" name="myview" class="com.supinfo.eclipseRCP.exemple.MyView" />
                </extension>
            </textarea>
            <p>La procédure pour la seconde vue est la même sauf qu’il faut indiquer « myviewright » comme id et comme nom et ajouter la ligne suivante dans le fichier plugin.xml :</p>
            <p>&gt;.</p>
            <!-- surement une erreur je ne suis pas un expert eclipse -->
            <p>Il nous reste plus qu’à créer les classes MyView et MyViewRight. Il faut donc créer deux nouvelles classes. Ces classes héritent de la classe ViewPart et doivent redéfinir les méthode createPartControl et setFocus. Il faut également déclarer une chaîne ID qui représente l’identifiant de la classe (celui présent dans plugin.xml). Il est ensuite possible sur chaque vue d’utiliser n’importe quel composant graphique de SWT. A noter qu’il est possible d’utiliser un plug-in comme Visual Editor ou Jigloo pour réaliser ses vues en drag and drop.</p>
            <p>Par exemple, sur la vue de droite nous créons un canvas sur lequel on place un label.</p>
            <textarea name="code" class="java">public class MyViewRight extends ViewPart{
				public static final String ID = "myviewright";
				private Canvas canvas;
				private Label lbTest;
				public void createPartControl(Composite parent){
				canvas = new Canvas(parent, SWT.Paint);
				lbTest = new Label(canvas, SWT.NONE);
				lbTest.setText("Un Label");
				lbTest.setBounds(4, 4, 40, 18);
				}
				public void setFocus() {}
				}</textarea>
            <p>Maintenant que les vues sont définies, il faut remplir la barre de menu puisque nous l’avons définie comme visible dans la classe ApplicationWorkbenchWindowAdvisor. Pour cela, il faut éditer la classe ApplicationActionBarAdvisor. Cette classe est donc composée de différentes méthodes qui permettent de remplir les « Action bar » et de définir des actions à exécuter pour chacun des menus.</p>
            <p>Il faut d’abord remplir la barre de menu :</p>
            <textarea name="code" class="java">protected void fillMenuBar(IMenuManager menuBar){
				MenuManager fileMenu = new MenuManager("&amp;Fichier", IWorkbenchActionConstants.M_FILE);
				MenuManager helpMenu = new MenuManager("&amp;A propos", IWorkbenchActionConstants.M_HELP);
				menuBar.add(fileMenu);
				menuBar.add(new GroupMarker(IWorkbenchActionConstants.MB_ADDITIONS));
				menuBar.add(helpMenu);
				// Fichier
				fileMenu.add(newWindowAction);
				fileMenu.add(openViewAction);
				fileMenu.add(new Separator());
				fileMenu.add(exitAction);
				// A propos
				helpMenu.add(aboutAction);
				}</textarea>
            <p>Ici nous utilisons les MenuManager de JFace qui permettent de gérer nos menus. On ajoute ensuite les menuManager à la barre de menu et, pour chaque menu, on ajoute des items sous formes d’instances de classes Actions (par exemple, openViewAction). Le rôle de ces classes est de rediriger toutes les actions possibles de l’utilisateur final (touches clavier, menus…) vers le code de traitement.</p>
            <p>L’environnement fournit des actions standard comme ceux utilisés ici dans la méthode makeActions (par exemple la ligne newWindowAction = ActionFactory.OPEN_NEW_WINDOW.create(window) va créer une deuxième instance de l’ application en cours dans une nouvelle fenêtre lorsque l’utilisateur cliquera sur ce menu).</p>
            <textarea name="code" class="java">protected void makeActions(IWorkbenchWindow window){
				exitAction = ActionFactory.QUIT.create(window);
				register(exitAction);
				aboutAction = ActionFactory.ABOUT.create(window);
				register(aboutAction);
				newWindowAction = ActionFactory.OPEN_NEW_WINDOW.create(window);
				register(newWindowAction);
				openViewAction = new OpenViewAction(window, "Ouvrir un nouvel onglet", MyView.ID);
				register(openViewAction);
				}</textarea>
            <p>Il est également possible de créer ses propres actions. C’est ce qui est fait ici avec l’Action OpenViewAction. Il faut alors créer une nouvelle classe dérivant de la classe Action :</p>
            <textarea name="code" class="java">public class OpenViewAction extends Action {
				private final IWorkbenchWindow window;
				private int instanceNum = 0;
				private final String viewId;
				public OpenViewAction(IWorkbenchWindow window, String label, String viewId) {
				this.window = window;
				this.viewId = viewId;
				setText(label);
				setId(“onglet.open”);
				setActionDefinitionId(“onglet.open”);
				}
				public void run() {
				if(window != null) {
				try {
				window.getActivePage().showView(viewId, Integer.toString(instanceNum++), IWorkbenchPage.VIEW_ACTIVATE);
				} catch (Exception e) {
				MessageDialog.openError(window.getShell(), "Error", "Error opening view:" + e.getMessage());
				}
				}
				}
				}</textarea>
            <p>Le constructeur prend comme paramètre l’instance de la fenêtre en cours, un label pour le menu et la vue dont il faut créer une nouvelle instance. Ici il s’agit de la vue centrale, l’action du clique sur ce menu permettra donc de créer un nouvel onglet sur notre vue de gauche.</p>
            <p>L’application est terminée. Pour tester son fonctionnement, il est possible de cliquer sur « Launch an Eclipse application » sur l’assistant de création de plug-in.</p>
            <img src="./images/article-EclipseRCP_html_2283d59.png" />
            <p>Il existe un assistant pour pouvoir exporter notre application pour qu’elle puisse être exécutable à l’extérieur d’Eclipse.</p>
            <p>
                La procédure à réaliser est la suivante : Clique droit sur le projet,
                <strong>New</strong>
                ,
                <strong>Product configuration</strong>
                . Il faut donner un nom de ficher à l’application (par exemple « ApplicationRCP.product »). Dans l’assistant qui apparaît, il faut cliquer sur
                <strong>New</strong>
                , choisir le projet à exporter et donner un ID (par exemple « ApplicationRCP.product »).
            </p>
            <p>
                Il faut ensuite aller dans
                <strong>l’onglet configuration</strong>
                et cliquer sur
                <strong>« Add required plugin »</strong>
                .
				En revenant sur l’onglet
                <strong>« Overview »</strong>
                , il est maintenant possible d’exporter l’application en cliquant sur
                <strong>« Eclipse Product Application Wizard »</strong>
                , dans l’assistant dans
                <strong>« Export destination »</strong>
                , il faut selectionner
                <strong>Directory</strong>
                et naviguer jusqu’au dossier où vous voulez exporter l’application.
            </p>
        </div>
        <div class="chapter">
            <h2>Conclusion</h2>
            <p>Nous avons donc vu comment créer des applications à l’aide d’Eclipse RCP et les différentes classes indispensables à son fonctionnement.</p>
            <p>Le deuxième exemple nous a permis de voir comment créer une application un peu plus complète comprenant plusieurs vues ainsi qu’un menu exécutant plusieurs actions. Ce deuxième exemple reste assez simple mais il montre bien comment créer une application de base avec Eclipse RCP.
				Il est ensuite possible de réutiliser de nombreux autres composants d’Eclipse (splash screen, boîtes de dialogue personnalisées, barres d’outils, icônes différentes sur chaque vues…) et créer entièrement ses applications client riche avec Eclipse RCP.</p>
            <p>
                Le site d’Eclipse en donne quelques exemples
                <a href="http://www.eclipse.org/community/rcpcp.php" target="”_blank”">ici</a>
                .
            </p>
        </div>
    </body>
</html>

